{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Locally Estimated Scatterplot Smoothing (LOESS)"
      ],
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": [
        "Loess s a non-parametric regression method that combines multiple regression models in a k-nearest-neighbor-based meta-model."
      ],
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "# yfinance is used to fetch data \n",
        "import yfinance as yf\n",
        "yf.pdr_override()"
      ],
      "outputs": [],
      "execution_count": 1,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false,
        "execution": {
          "iopub.status.busy": "2021-02-02T02:04:00.840Z",
          "iopub.execute_input": "2021-02-02T02:04:00.867Z",
          "iopub.status.idle": "2021-02-02T02:04:07.509Z",
          "shell.execute_reply": "2021-02-02T02:04:07.487Z"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# input\n",
        "symbol = 'AMD'\n",
        "start = '2014-01-01'\n",
        "end = '2018-08-27'\n",
        "\n",
        "# Read data \n",
        "dataset = yf.download(symbol,start,end)\n",
        "\n",
        "# View Columns\n",
        "dataset.head()"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[*********************100%***********************]  1 of 1 completed\n"
          ]
        },
        {
          "output_type": "execute_result",
          "execution_count": 2,
          "data": {
            "text/plain": "            Open  High   Low  Close  Adj Close    Volume\nDate                                                    \n2014-01-02  3.85  3.98  3.84   3.95       3.95  20548400\n2014-01-03  3.98  4.00  3.88   4.00       4.00  22887200\n2014-01-06  4.01  4.18  3.99   4.13       4.13  42398300\n2014-01-07  4.19  4.25  4.11   4.18       4.18  42932100\n2014-01-08  4.23  4.26  4.14   4.18       4.18  30678700",
            "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Open</th>\n      <th>High</th>\n      <th>Low</th>\n      <th>Close</th>\n      <th>Adj Close</th>\n      <th>Volume</th>\n    </tr>\n    <tr>\n      <th>Date</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>2014-01-02</th>\n      <td>3.85</td>\n      <td>3.98</td>\n      <td>3.84</td>\n      <td>3.95</td>\n      <td>3.95</td>\n      <td>20548400</td>\n    </tr>\n    <tr>\n      <th>2014-01-03</th>\n      <td>3.98</td>\n      <td>4.00</td>\n      <td>3.88</td>\n      <td>4.00</td>\n      <td>4.00</td>\n      <td>22887200</td>\n    </tr>\n    <tr>\n      <th>2014-01-06</th>\n      <td>4.01</td>\n      <td>4.18</td>\n      <td>3.99</td>\n      <td>4.13</td>\n      <td>4.13</td>\n      <td>42398300</td>\n    </tr>\n    <tr>\n      <th>2014-01-07</th>\n      <td>4.19</td>\n      <td>4.25</td>\n      <td>4.11</td>\n      <td>4.18</td>\n      <td>4.18</td>\n      <td>42932100</td>\n    </tr>\n    <tr>\n      <th>2014-01-08</th>\n      <td>4.23</td>\n      <td>4.26</td>\n      <td>4.14</td>\n      <td>4.18</td>\n      <td>4.18</td>\n      <td>30678700</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
          },
          "metadata": {}
        }
      ],
      "execution_count": 2,
      "metadata": {
        "collapsed": false,
        "outputHidden": false,
        "inputHidden": false,
        "execution": {
          "iopub.status.busy": "2021-02-02T02:04:07.531Z",
          "iopub.execute_input": "2021-02-02T02:04:07.547Z",
          "iopub.status.idle": "2021-02-02T02:04:10.158Z",
          "shell.execute_reply": "2021-02-02T02:04:10.389Z"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "import scipy.stats as stats\n",
        "import statsmodels.api as sm\n",
        "\n",
        "lowess = sm.nonparametric.lowess"
      ],
      "outputs": [],
      "execution_count": 3,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2021-02-02T02:04:10.199Z",
          "iopub.execute_input": "2021-02-02T02:04:10.257Z",
          "iopub.status.idle": "2021-02-02T02:04:16.189Z",
          "shell.execute_reply": "2021-02-02T02:04:16.364Z"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = dataset['Adj Close']\n",
        "y = np.sin(x) + stats.cauchy.rvs(size=len(x))\n",
        "z = lowess(y, x, frac= 1./3, it=0)\n",
        "w = lowess(y, x, frac=1./3)"
      ],
      "outputs": [],
      "execution_count": 4,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2021-02-02T02:04:16.223Z",
          "iopub.execute_input": "2021-02-02T02:04:16.262Z",
          "iopub.status.idle": "2021-02-02T02:04:18.289Z",
          "shell.execute_reply": "2021-02-02T02:04:19.332Z"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import scipy"
      ],
      "outputs": [],
      "execution_count": 5,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2021-02-02T02:04:18.347Z",
          "iopub.execute_input": "2021-02-02T02:04:18.375Z",
          "iopub.status.idle": "2021-02-02T02:04:18.426Z",
          "shell.execute_reply": "2021-02-02T02:04:19.384Z"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# http://www.jtrive.com/loess-nonparametric-scatterplot-smoothing-in-python.html\n",
        "\n",
        "def loc_eval(x, b):\n",
        "    \"\"\"\n",
        "    Evaluate `x` using locally-weighted regression parameters.\n",
        "    Degree of polynomial used in loess is inferred from b. `x`\n",
        "    is assumed to be a scalar.\n",
        "    \"\"\"\n",
        "    loc_est = 0\n",
        "    for i in enumerate(b): loc_est+=i[1]*(x**i[0])\n",
        "    return(loc_est)\n",
        "\n",
        "\n",
        "\n",
        "def loess(xvals, yvals, alpha, poly_degree=1):\n",
        "    \"\"\"\n",
        "    Perform locally-weighted regression on xvals & yvals.\n",
        "    Variables used inside `loess` function:\n",
        "\n",
        "        n         => number of data points in xvals\n",
        "        m         => nbr of LOESS evaluation points\n",
        "        q         => number of data points used for each\n",
        "                     locally-weighted regression\n",
        "        v         => x-value locations for evaluating LOESS\n",
        "        locsDF    => contains local regression details for each\n",
        "                     location v\n",
        "        evalDF    => contains actual LOESS output for each v\n",
        "        X         => n-by-(poly_degree+1) design matrix\n",
        "        W         => n-by-n diagonal weight matrix for each\n",
        "                     local regression\n",
        "        y         => yvals\n",
        "        b         => local regression coefficient estimates.\n",
        "                     b = `(X^T*W*X)^-1*X^T*W*y`. Note that `@`\n",
        "                     replaces `np.dot` in recent numpy versions.\n",
        "        local_est => response for local regression\n",
        "    \"\"\"\n",
        "    # Sort dataset by xvals.\n",
        "    all_data = sorted(zip(xvals, yvals), key=lambda x: x[0])\n",
        "    xvals, yvals = zip(*all_data)\n",
        "\n",
        "    locsDF = pd.DataFrame(\n",
        "                columns=[\n",
        "                  'loc','x','weights','v','y','raw_dists',\n",
        "                  'scale_factor','scaled_dists'\n",
        "                  ])\n",
        "    evalDF = pd.DataFrame(\n",
        "                columns=[\n",
        "                  'loc','est','b','v','g'\n",
        "                  ])\n",
        "\n",
        "    n = len(xvals)\n",
        "    m = n + 1\n",
        "    q = int(np.floor(n * alpha) if alpha <= 1.0 else n)\n",
        "    avg_interval = ((max(xvals)-min(xvals))/len(xvals))\n",
        "    v_lb = max(0,min(xvals)-(.5*avg_interval))\n",
        "    v_ub = (max(xvals)+(.5*avg_interval))\n",
        "    v = enumerate(np.linspace(start=v_lb, stop=v_ub, num=m), start=1)\n",
        "\n",
        "    # Generate design matrix based on poly_degree.\n",
        "    xcols = [np.ones_like(xvals)]\n",
        "    for j in range(1, (poly_degree + 1)):\n",
        "        xcols.append([i ** j for i in xvals])\n",
        "    X = np.vstack(xcols).T\n",
        "\n",
        "\n",
        "    for i in v:\n",
        "\n",
        "        iterpos = i[0]\n",
        "        iterval = i[1]\n",
        "\n",
        "        # Determine q-nearest xvals to iterval.\n",
        "        iterdists = sorted([(j, np.abs(j-iterval)) \\\n",
        "                           for j in xvals], key=lambda x: x[1])\n",
        "\n",
        "        _, raw_dists = zip(*iterdists)\n",
        "\n",
        "        # Scale local observations by qth-nearest raw_dist.\n",
        "        scale_fact = raw_dists[q-1]\n",
        "        scaled_dists = [(j[0],(j[1]/scale_fact)) for j in iterdists]\n",
        "        weights = [(j[0],((1-np.abs(j[1]**3))**3 \\\n",
        "                      if j[1]<=1 else 0)) for j in scaled_dists]\n",
        "\n",
        "        # Remove xvals from each tuple:\n",
        "        _, weights      = zip(*sorted(weights,     key=lambda x: x[0]))\n",
        "        _, raw_dists    = zip(*sorted(iterdists,   key=lambda x: x[0]))\n",
        "        _, scaled_dists = zip(*sorted(scaled_dists,key=lambda x: x[0]))\n",
        "\n",
        "        iterDF1 = pd.DataFrame({\n",
        "                    'loc'         :iterpos,\n",
        "                    'x'           :xvals,\n",
        "                    'v'           :iterval,\n",
        "                    'weights'     :weights,\n",
        "                    'y'           :yvals,\n",
        "                    'raw_dists'   :raw_dists,\n",
        "                    'scale_fact'  :scale_fact,\n",
        "                    'scaled_dists':scaled_dists\n",
        "                    })\n",
        "\n",
        "        locsDF    = pd.concat([locsDF, iterDF1])\n",
        "        W         = np.diag(weights)\n",
        "        y         = yvals\n",
        "        b         = np.linalg.inv(X.T @ W @ X) @ (X.T @ W @ y)\n",
        "        local_est = loc_eval(iterval, b)\n",
        "        iterDF2   = pd.DataFrame({\n",
        "                       'loc':[iterpos],\n",
        "                       'b'  :[b],\n",
        "                       'v'  :[iterval],\n",
        "                       'g'  :[local_est]\n",
        "                       })\n",
        "\n",
        "        evalDF = pd.concat([evalDF, iterDF2])\n",
        "\n",
        "    # Reset indicies for returned DataFrames.\n",
        "    locsDF.reset_index(inplace=True)\n",
        "    locsDF.drop('index', axis=1, inplace=True)\n",
        "    locsDF['est'] = 0; evalDF['est'] = 0\n",
        "    locsDF = locsDF[['loc','est','v','x','y','raw_dists',\n",
        "                     'scale_fact','scaled_dists','weights']]\n",
        "\n",
        "    # Reset index for evalDF.\n",
        "    evalDF.reset_index(inplace=True)\n",
        "    evalDF.drop('index', axis=1, inplace=True)\n",
        "    evalDF = evalDF[['loc','est', 'v', 'b', 'g']]\n",
        "\n",
        "    return(locsDF, evalDF)"
      ],
      "outputs": [],
      "execution_count": 6,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2021-02-02T02:04:18.464Z",
          "iopub.execute_input": "2021-02-02T02:04:18.569Z",
          "iopub.status.idle": "2021-02-02T02:04:18.817Z",
          "shell.execute_reply": "2021-02-02T02:04:19.405Z"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "xvals = dataset['Open']\n",
        "yvals = dataset['Adj Close']"
      ],
      "outputs": [],
      "execution_count": 7,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "shell.execute_reply": "2021-02-02T02:04:19.424Z",
          "iopub.status.busy": "2021-02-02T02:04:18.866Z",
          "iopub.execute_input": "2021-02-02T02:04:18.902Z",
          "iopub.status.idle": "2021-02-02T02:04:19.079Z"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "regsDF, evalDF = loess(xvals, yvals, alpha=.6, poly_degree=1)"
      ],
      "outputs": [],
      "execution_count": 8,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2021-02-02T02:04:19.125Z",
          "iopub.execute_input": "2021-02-02T02:04:19.152Z",
          "shell.execute_reply": "2021-02-02T02:26:48.096Z",
          "iopub.status.idle": "2021-02-02T02:26:47.761Z"
        }
      }
    },
    {
      "cell_type": "code",
      "source": [
        "l_x  = evalDF['v'].values\n",
        "l_y  = evalDF['g'].values\n",
        "\n",
        "# Generate x-y scatterplot with loess estimate overlaid.\n",
        "fig = plt.figure()\n",
        "ax1 = fig.add_subplot(111)\n",
        "ax1.grid(True)\n",
        "ax1.minorticks_on()\n",
        "ax1.scatter(xvals, yvals, label=\"Original Data\")\n",
        "ax1.plot(l_x, l_y, color='#FF0000', label=\"1st-degree Polynomial LOESS\")\n",
        "ax1.set_title(\"Linear LOESS Estimator\", loc=\"left\", fontsize=14)\n",
        "ax1.legend(loc=\"upper left\",\n",
        "           scatterpoints=1,\n",
        "           fontsize=11,\n",
        "           frameon=True,\n",
        "           fancybox=True,\n",
        "           facecolor=\"#FFFFFF\",\n",
        "           edgecolor=\"#000000\")\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 432x288 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "execution_count": 9,
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "source_hidden": false,
          "outputs_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        },
        "execution": {
          "iopub.status.busy": "2021-02-02T02:26:47.896Z",
          "iopub.execute_input": "2021-02-02T02:26:48.045Z",
          "iopub.status.idle": "2021-02-02T02:26:49.850Z",
          "shell.execute_reply": "2021-02-02T02:26:51.171Z"
        }
      }
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.6.5",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "kernelspec": {
      "name": "python3",
      "language": "python",
      "display_name": "Python 3"
    },
    "nteract": {
      "version": "0.28.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}